Scikit-learn Preprocessing: Beherskelse af datatransformationspipelines til Machine Learning

Inden for machine learning har kvaliteten af dine data en direkte indvirkning på dine modellers ydeevne. Rådata indeholder ofte uoverensstemmelser, manglende værdier og varierende skalaer, hvilket gør dem uegnede til direkte brug. Scikit-learn, et kraftfuldt Python-bibliotek, tilbyder en omfattende pakke af preprocessing-teknikker til at omdanne dine data til et format, der er egnet til machine learning-algoritmer. Denne artikel dykker ned i verdenen af Scikit-learn preprocessing med fokus på oprettelse og anvendelse af datatransformationspipelines for at strømline dine machine learning-workflows.

Hvorfor data-preprocessing er afgørende

Data-preprocessing er processen med at rense, transformere og organisere rådata for at gøre dem mere egnede til machine learning-modeller. Det er et afgørende skridt, fordi machine learning-algoritmer er følsomme over for skalaen og fordelingen af input-features. Uden korrekt preprocessing kan modeller yde dårligt, hvilket fører til unøjagtige forudsigelser og upålidelige resultater. Her er nogle af de vigtigste grunde til, at data-preprocessing er essentielt:

• Forbedret modelpræstation: Præprocesserede data gør det muligt for modeller at lære mere effektivt og opnå højere nøjagtighed.
• Håndterer manglende værdier: Imputationsteknikker udfylder manglende datapunkter og forhindrer algoritmer i at gå ned eller producere partiske resultater.
• Standardiserer feature-skalaer: Skaleringsmetoder sikrer, at alle features bidrager ligeligt til modellen, hvilket forhindrer features med større værdier i at dominere læringsprocessen.
• Koder kategoriske variable: Kodningsteknikker konverterer kategoriske data til numeriske repræsentationer, som machine learning-algoritmer kan forstå.
• Reducerer støj og outliers: Preprocessing kan hjælpe med at mindske virkningen af outliers og støjende data, hvilket fører til mere robuste modeller.

Introduktion til Scikit-learn Pipelines

Scikit-learn Pipelines giver en måde at sammenkæde flere datatransformationstrin i et enkelt, genanvendeligt objekt. Dette forenkler din kode, forbedrer læsbarheden og forhindrer datalækage under modelevaluering. En pipeline er i bund og grund en sekvens af datatransformationer efterfulgt af en endelig estimator (f.eks. en klassifikator eller regressor). Her er hvorfor pipelines er så fordelagtige:

• Kodeorganisering: Pipelines indkapsler hele data-preprocessing og modellerings-workflowet i en enkelt enhed, hvilket gør din kode mere organiseret og lettere at vedligeholde.
• Forebyggelse af datalækage: Pipelines sikrer, at datatransformationer anvendes konsekvent på både trænings- og testdata, hvilket forhindrer datalækage, som kan føre til overfitting og dårlig generalisering.
• Forenklet modelevaluering: Pipelines gør det lettere at evaluere din models ydeevne ved hjælp af teknikker som krydsvalidering, da hele preprocessing- og modellerings-workflowet anvendes konsekvent på hvert fold.
• Strømlinet implementering: Pipelines kan let implementeres i produktionsmiljøer, hvilket sikrer, at data forbehandles på samme måde som under træningen.

Almindelige data-preprocessingsteknikker i Scikit-learn

Scikit-learn tilbyder en bred vifte af preprocessing-teknikker. Her er nogle af de mest almindeligt anvendte:

1. Skalering og normalisering

Skalering og normalisering er teknikker, der bruges til at transformere numeriske features til et lignende værdiområde. Dette er vigtigt, fordi features med forskellige skalaer kan påvirke læringsprocessen uforholdsmæssigt. Scikit-learn tilbyder flere skalerings- og normaliseringsmetoder:

• StandardScaler: Standardiserer features ved at fjerne gennemsnittet og skalere til enhedsvarians. Dette er en meget anvendt teknik, der antager, at data følger en normalfordeling.

  Formel: x_scaled = (x - mean) / standard_deviation

  Eksempel: Antag, at du har huspriser i USD og areal i kvadratmeter. Skalering af disse features sikrer, at modellen ikke tillægger unødig vægt til den feature med større værdier (f.eks. huspriser).

• MinMaxScaler: Skalerer features til et specificeret interval, typisk mellem 0 og 1. Dette er nyttigt, når du vil bevare dataenes oprindelige fordeling.

  Formel: x_scaled = (x - min) / (max - min)

  Eksempel: Billedbehandling bruger ofte MinMaxScaler til at normalisere pixelværdier til intervallet [0, 1].

• RobustScaler: Skalerer features ved hjælp af statistikker, der er robuste over for outliers, såsom medianen og interkvartilområdet (IQR). Dette er et godt valg, når dine data indeholder outliers.

  Formel: x_scaled = (x - median) / IQR

  Eksempel: I finansielle datasæt, hvor outliers er almindelige (f.eks. ekstreme udsving på aktiemarkedet), kan RobustScaler give mere stabile resultater.

• Normalizer: Normaliserer samples individuelt til enhedsnorm. Dette er nyttigt, når størrelsen af feature-vektoren er vigtigere end de individuelle feature-værdier.

  Formel (L2-norm): x_scaled = x / ||x||

  Eksempel: I tekstbehandling er normalisering af term frequency-inverse document frequency (TF-IDF) vektorer en almindelig praksis.

2. Kodning af kategoriske variable

Machine learning-algoritmer kræver typisk numerisk input, så kategoriske variable skal konverteres til numeriske repræsentationer. Scikit-learn tilbyder flere kodningsteknikker:

• OneHotEncoder: Opretter binære kolonner for hver kategori i featuren. Dette er velegnet til nominelle kategoriske features (features uden en iboende rækkefølge).

  Eksempel: Kodning af en "country"-feature med værdier som "USA," "Canada," og "UK" ville oprette tre nye kolonner: "country_USA," "country_Canada," og "country_UK."

• OrdinalEncoder: Tildeler en heltalsværdi til hver kategori baseret på dens rækkefølge. Dette er passende for ordinale kategoriske features (features med en meningsfuld rækkefølge).

  Eksempel: Kodning af en "education level"-feature med værdier som "High School," "Bachelor's," og "Master's" ville tildele heltalsværdier som henholdsvis 0, 1 og 2.

• LabelEncoder: Koder target labels med værdier mellem 0 og n_classes-1. Brug dette til at kode target-variablen i klassifikationsproblemer.

  Eksempel: Kodning af "spam" og "not spam" labels som henholdsvis 0 og 1.

• TargetEncoder (kræver category_encoders-biblioteket): Koder kategoriske features baseret på gennemsnittet af target-variablen for hver kategori. Kan føre til target-lækage, hvis det ikke bruges forsigtigt inden for en krydsvalideringsopsætning.

3. Håndtering af manglende værdier

Manglende værdier er et almindeligt problem i virkelige datasæt. Scikit-learn tilbyder teknikker til at imputere (udfylde) manglende værdier:

• SimpleImputer: Imputerer manglende værdier ved hjælp af en konstant værdi, gennemsnittet, medianen eller den hyppigst forekommende værdi af featuren.
• KNNImputer: Imputerer manglende værdier ved hjælp af k-nearest neighbors-algoritmen. Den finder de k nærmeste samples til den sample med manglende værdier og bruger gennemsnitsværdien af disse naboer til at imputere den manglende værdi.
• IterativeImputer: Imputerer manglende værdier ved hjælp af en iterativ modelleringsmetode. Hver feature med manglende værdier modelleres som en funktion af de andre features, og de manglende værdier forudsiges iterativt.

4. Feature-transformation

Feature-transformation indebærer at skabe nye features fra eksisterende. Dette kan forbedre modelpræstationen ved at fange ikke-lineære sammenhænge eller interaktioner mellem features. Nogle teknikker inkluderer:

• PolynomialFeatures: Genererer polynomiske kombinationer af features. For eksempel, hvis du har to features x1 og x2, kan PolynomialFeatures skabe nye features som x1^2, x2^2, x1*x2.
• FunctionTransformer: Anvender en brugerdefineret funktion på features. Dette giver dig mulighed for at udføre vilkårlige transformationer, såsom logaritmiske eller eksponentielle transformationer.
• PowerTransformer: Anvender en power-transformation for at gøre data mere Gauss-lignende. Dette kan være nyttigt for algoritmer, der antager normalitet, såsom lineær regression. (Inkluderer Box-Cox og Yeo-Johnson transformationer)

Opbygning af datatransformationspipelines med Scikit-learn

Lad os nu omsætte disse preprocessing-teknikker til praksis ved at bygge datatransformationspipelines. Her er en trin-for-trin guide:

1. Importer nødvendige biblioteker

Start med at importere de nødvendige biblioteker fra Scikit-learn:

from sklearn.pipeline import Pipeline from sklearn.preprocessing import StandardScaler, OneHotEncoder, SimpleImputer from sklearn.compose import ColumnTransformer from sklearn.model_selection import train_test_split from sklearn.linear_model import LogisticRegression import pandas as pd

2. Indlæs og forbered dine data

Indlæs dit datasæt ved hjælp af pandas eller en anden passende metode. Identificer de numeriske og kategoriske features i dit datasæt. For eksempel:

data = { 'age': [25, 30, 35, 40, 45, None], 'country': ['USA', 'Canada', 'USA', 'UK', 'Canada', 'USA'], 'salary': [50000, 60000, 70000, 80000, 90000, 55000], 'purchased': [0, 1, 0, 1, 0, 1] } df = pd.DataFrame(data)

3. Definer preprocessing-trin

Opret instanser af de preprocessing-transformere, du vil bruge. For eksempel kan du til at håndtere numeriske features bruge StandardScaler og SimpleImputer. Til kategoriske features kan du bruge OneHotEncoder. Overvej at inkludere strategier til håndtering af manglende værdier før skalering eller kodning.

numerical_features = ['age', 'salary'] categorical_features = ['country'] numerical_transformer = Pipeline(steps=[ ('imputer', SimpleImputer(strategy='mean')), ('scaler', StandardScaler()) ]) categorical_transformer = Pipeline(steps=[ ('onehot', OneHotEncoder(handle_unknown='ignore')) ])

4. Opret en ColumnTransformer

Brug ColumnTransformer til at anvende forskellige transformere på forskellige kolonner i dine data. Dette giver dig mulighed for at forbehandle numeriske og kategoriske features separat.

preprocessor = ColumnTransformer( transformers=[ ('num', numerical_transformer, numerical_features), ('cat', categorical_transformer, categorical_features) ])

5. Byg pipelinen

Opret et Pipeline-objekt, der sammenkæder preprocessing-trinene med en machine learning-model. Dette sikrer, at dataene forbehandles konsekvent, før de fødes til modellen.

pipeline = Pipeline(steps=[('preprocessor', preprocessor), ('classifier', LogisticRegression())])

6. Træn og evaluer modellen

Opdel dine data i trænings- og testsæt. Træn derefter pipelinen på træningsdataene og evaluer dens ydeevne på testdataene.

X = df.drop('purchased', axis=1) y = df['purchased'] X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=42) pipeline.fit(X_train, y_train) score = pipeline.score(X_test, y_test) print(f'Modelnøjagtighed: {score}')

Komplet eksempelkode

Her er den komplette kode til at bygge og træne en datatransformationspipeline:

import pandas as pd from sklearn.pipeline import Pipeline from sklearn.preprocessing import StandardScaler, OneHotEncoder, SimpleImputer from sklearn.compose import ColumnTransformer from sklearn.model_selection import train_test_split from sklearn.linear_model import LogisticRegression # Eksempeldata data = { 'age': [25, 30, 35, 40, 45, None], 'country': ['USA', 'Canada', 'USA', 'UK', 'Canada', 'USA'], 'salary': [50000, 60000, 70000, 80000, 90000, 55000], 'purchased': [0, 1, 0, 1, 0, 1] } df = pd.DataFrame(data) # Definer features numerical_features = ['age', 'salary'] categorical_features = ['country'] # Opret transformere numerical_transformer = Pipeline(steps=[ ('imputer', SimpleImputer(strategy='mean')), ('scaler', StandardScaler()) ]) categorical_transformer = Pipeline(steps=[ ('onehot', OneHotEncoder(handle_unknown='ignore')) ]) # Opret preprocessor preprocessor = ColumnTransformer( transformers=[ ('num', numerical_transformer, numerical_features), ('cat', categorical_transformer, categorical_features) ]) # Opret pipeline pipeline = Pipeline(steps=[('preprocessor', preprocessor), ('classifier', LogisticRegression())]) # Opdel data X = df.drop('purchased', axis=1) y = df['purchased'] X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=42) # Træn model pipeline.fit(X_train, y_train) # Evaluer model score = pipeline.score(X_test, y_test) print(f'Modelnøjagtighed: {score}')

Avancerede pipeline-teknikker

Når du er fortrolig med det grundlæggende, kan du udforske mere avancerede pipeline-teknikker:

1. Brugerdefinerede transformere

Du kan oprette dine egne brugerdefinerede transformere til at udføre specifikke datatransformationer, der ikke er tilgængelige i Scikit-learn. For at oprette en brugerdefineret transformer skal du arve fra TransformerMixin- og BaseEstimator-klasserne og implementere fit- og transform-metoderne. Dette kan være nyttigt til feature engineering eller domænespecifikke transformationer. Husk at inkludere passende docstrings for læsbarhed.

2. FeatureUnion

FeatureUnion giver dig mulighed for at kombinere outputtet fra flere transformere til en enkelt feature-vektor. Dette kan være nyttigt, når du vil anvende forskellige transformationer på de samme features eller kombinere features, der er blevet transformeret på forskellige måder. FeatureUnion-klassen bruges til at kombinere outputtet fra flere transformere til en enkelt feature-vektor.

3. Gittersøgning (Grid Search) med pipelines

Du kan bruge GridSearchCV til at optimere hyperparametrene i din pipeline, herunder hyperparametrene for preprocessing-trinene. Dette giver dig mulighed for automatisk at finde den bedste kombination af preprocessing-teknikker og modelparametre. Vær opmærksom på de øgede beregningsomkostninger.

Bedste praksis for data-preprocessing pipelines

Her er nogle bedste praksisser, du skal huske på, når du bygger data-preprocessing pipelines:

• Forstå dine data: Før du anvender nogen preprocessing-teknikker, skal du tage dig tid til at forstå dine data. Udforsk fordelingerne af dine features, identificer manglende værdier, og led efter outliers.
• Dokumenter din pipeline: Tilføj kommentarer til din kode for at forklare hvert trin i pipelinen. Dette vil gøre det lettere at forstå og vedligeholde din kode.
• Test din pipeline: Test din pipeline grundigt for at sikre, at den fungerer korrekt. Brug enhedstests til at verificere, at hvert trin i pipelinen producerer det forventede output.
• Undgå datalækage: Vær forsigtig med at undgå datalækage, når du forbehandler dine data. Sørg for, at du kun bruger information fra træningsdataene til at forbehandle træningsdataene. Brug pipelines til at sikre konsistens mellem trænings- og testdata.
• Overvåg ydeevne: Overvåg din models ydeevne over tid og gen-træn den efter behov. Datafordelinger kan ændre sig over tid, så det er vigtigt periodisk at re-evaluere din pipeline og foretage justeringer efter behov.

Eksempler fra den virkelige verden

Lad os udforske nogle eksempler fra den virkelige verden på, hvordan datatransformationspipelines kan bruges i forskellige brancher:

• Finans: I kreditrisikomodellering kan pipelines bruges til at forbehandle kundedata, herunder numeriske features som indkomst og kreditvurdering, samt kategoriske features som ansættelsesstatus og låneformål. Manglende værdier kan imputeres ved hjælp af teknikker som gennemsnitsimputation eller k-nearest neighbors imputation. Skalering er afgørende for at sikre, at features med forskellige skalaer ikke dominerer modellen.
• Sundhedsvæsen: I medicinsk diagnose kan pipelines bruges til at forbehandle patientdata, herunder numeriske features som alder, blodtryk og kolesterolniveauer, samt kategoriske features som køn og sygehistorie. One-hot encoding kan bruges til at konvertere kategoriske features til numeriske repræsentationer.
• E-handel: I produktanbefalingssystemer kan pipelines bruges til at forbehandle kunde- og produktdata, herunder numeriske features som købsfrekvens og produktvurderinger, samt kategoriske features som produktkategori og kundedemografi. Pipelines kan omfatte trin til tekst-preprocessing, såsom tokenisering og stemming, for at udtrække features fra produktbeskrivelser og kundeanmeldelser.
• Produktion: I prædiktiv vedligeholdelse kan pipelines bruges til at forbehandle sensordata fra maskiner, herunder numeriske features som temperatur, tryk og vibration, samt kategoriske features som maskintype og driftsforhold. RobustScaler kan være særligt nyttig her på grund af potentialet for outlier-aflæsninger.

Håndtering af udfordringer i globale datasæt

Når man arbejder med globale datasæt, støder man ofte på specifikke udfordringer, der kræver omhyggelig overvejelse under preprocessing. Her er nogle almindelige problemer og strategier til at håndtere dem:

• Varierende dataformater: Datoer, tal og valutaer kan have forskellige formater på tværs af regioner. Sørg for konsekvent parsing og formatering. For eksempel kan datoer være i DD/MM/ÅÅÅÅ- eller MM/DD/ÅÅÅÅ-format. Brug passende biblioteker til at håndtere datokonverteringer og formatering.
• Sprogforskelle: Tekstdata kan være på forskellige sprog, hvilket kræver oversættelse eller sprogspecifikke preprocessing-teknikker. Overvej at bruge biblioteker som Google Translate API (med passende brugsovervejelser og omkostningsimplikationer) til oversættelse eller NLTK til sprogspecifik tekstbehandling.
• Valutakonvertering: Finansielle data kan være i forskellige valutaer. Konverter alle værdier til en fælles valuta ved hjælp af opdaterede valutakurser. Brug pålidelige API'er til at få nøjagtige valutakurser i realtid.
• Tidszoner: Tidsseriedata kan være registreret i forskellige tidszoner. Konverter alle tidsstempler til en fælles tidszone (f.eks. UTC) for at sikre konsistens. Brug biblioteker som pytz til at håndtere tidszonekonverteringer.
• Kulturelle forskelle: Kulturelle nuancer kan påvirke datatolkningen. For eksempel kan kundetilfredshedsscores tolkes forskelligt på tværs af kulturer. Vær opmærksom på disse nuancer og overvej dem, når du designer dine preprocessing-trin.
• Datakvalitetsproblemer: Datakvaliteten kan variere betydeligt på tværs af forskellige kilder. Implementer robuste datavaliderings- og renseprocedurer for at identificere og rette fejl.

Konklusion

Data-preprocessing er et kritisk skridt i machine learning-pipelinen. Ved at bruge Scikit-learn pipelines kan du strømline dit workflow, forhindre datalækage og forbedre dine modellers ydeevne. At mestre disse teknikker vil give dig mulighed for at bygge mere robuste og pålidelige machine learning-løsninger til en bred vifte af applikationer. Husk at tilpasse preprocessing-trinene til de specifikke karakteristika for dine data og kravene til din machine learning-model. Eksperimenter med forskellige teknikker for at finde den optimale kombination til dit specifikke problem. Ved at investere tid i korrekt data-preprocessing kan du frigøre det fulde potentiale i dine machine learning-algoritmer og opnå overlegne resultater.